package figuras.malla;

import java.util.ArrayList;

import javax.media.opengl.GL;

import figuras.BSplines;
import figuras.PuntoVector;

public class MallaMediaRevolucion extends Malla {

	//private int verticesRot;

	public MallaMediaRevolucion(ArrayList<PuntoVector> puntosDeControl,
			double radianes, int pasos) {
		aproximaSplineYCrea(puntosDeControl, radianes, pasos);
		//this.verticesRot = (int) (2 * Math.PI / radianes);
	}

	public void aproximaSplineYCrea(ArrayList<PuntoVector> puntosDeControl,
			double radianes, int pasos) {
		// aproximar por Spline
		int n = puntosDeControl.size();
		BSplines b = new BSplines();
		b.setPuntosControl(puntosDeControl);
		ArrayList<PuntoVector> perfil = b.aproxima(2, n, pasos);
		n = pasos + 1;
		// revolucionar perfil
		int verticesRot = (int) (2 * Math.PI / radianes);
		nCaras = (n - 1) * (verticesRot);
		nVertices = (((verticesRot / 2) + 1) * n);
		nNormales = nCaras;
		vertices = new PuntoVector[nVertices];
		normales = new PuntoVector[nNormales];
		caras = new Cara[nCaras];
		int contador = 0;

		for (int i = 0; i < n; i++) {
			PuntoVector origen = perfil.get(i);
			double anguloIni = Math.atan2(origen.getZ(), origen.getX());

			for (int j = 0; j <= verticesRot / 2; j++) {
				double angulo = anguloIni + radianes * j;
				PuntoVector destino = new PuntoVector(0.0f, origen.getY(),
						0.0f, 1);
				double radio = origen.distancia(destino);
				double z = radio * Math.sin(angulo);
				double x = radio * Math.cos(angulo);
				double y = origen.getY();
				vertices[j * n + i] = new PuntoVector((float) x, (float) y,
						(float) z, 1);

				if ((i > 0) && (j > 0)) {
					ArrayList<VerticeNormal> vector = new ArrayList<VerticeNormal>();
					vector.add(new VerticeNormal((j * n + i) % nVertices,
							contador));
					vector.add(new VerticeNormal((j * n + (i - 1)) % nVertices,
							contador));
					vector.add(new VerticeNormal(((j - 1) * n + i) % nVertices,
							contador));
					caras[contador] = new Cara(3, vector);
					normales[contador] = caras[contador].calculaNormal(
							vertices, contador);
					contador++;

					vector = new ArrayList<VerticeNormal>();
					vector.add(new VerticeNormal(((j - 1) * n + i) % nVertices,
							contador));
					vector.add(new VerticeNormal((j * n + (i - 1)) % nVertices,
							contador));
					vector.add(new VerticeNormal(((j - 1) * n + (i - 1))
							% nVertices, contador));
					
					caras[contador] = new Cara(3, vector);
					normales[contador] = caras[contador].calculaNormal(
							vertices, contador);
					contador++;
				}
			}
		}
	}
	public void dibuja(int modo,GL gl,ArrayList<BSplines> bsplines){
//		PuntoVector p1=bsplines.get(1).getPerfil().get(0);
//		PuntoVector p2=bsplines.get(0).getPerfil().get(
//				bsplines.get(0).getPerfil().size()-1);
//		PuntoVector vectorTraslacion=p1.obtenVector(p2);
//		gl.glMatrixMode(GL.GL_MODELVIEW);
//		gl.glPushMatrix();
//		gl.glTranslated(vectorTraslacion.getX()-Consts.DESPLAZAMIENTO_CABEZA,
//				vectorTraslacion.getY(), vectorTraslacion.getZ());
//		gl.glRotated(-90,0, 0, 1);
//		gl.glRotated(-90, 0, 1, 0);
	    for(int i=0;i<nCaras;i++){
	    	gl.glBegin(modo);
	        int vertCaras=caras[i].getNumVertices();
	        for(int j=0;j<vertCaras;j++){
	            int iV=caras[i].getIndiceVertice(j);
	            int iN=caras[i].getIndiceNormal(j);	            
	            gl.glNormal3d(normales[iN].getX(),normales[iN].getY(),normales[iN].getZ());
	            gl.glVertex3d(vertices[iV].getX(),vertices[iV].getY(),vertices[iV].getZ());	            
	        }
	        gl.glEnd();
	    }
	   // gl.glPopMatrix();
	}
}
